From 6b32c4d73fde826b66a75265108d125539331486 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Thu, 15 Dec 2016 01:12:21 +0300
Subject: [PATCH] Refactor packages specification

---
 src/cargo/ops/cargo_compile.rs         | 46 +++++++++++++++-----------
 src/cargo/ops/cargo_output_metadata.rs | 11 +++---
 2 files changed, 32 insertions(+), 25 deletions(-)

diff --git a/src/cargo/ops/cargo_compile.rs b/src/cargo/ops/cargo_compile.rs
index c72ba0b59..1102f4b7f 100644
--- a/src/cargo/ops/cargo_compile.rs
+++ b/src/cargo/ops/cargo_compile.rs
@@ -47,7 +47,7 @@ pub struct CompileOptions<'a> {
     pub all_features: bool,
     /// Flag if the default feature should be built for the root package
     pub no_default_features: bool,
-    /// Root package to build (if empty it's the current one)
+    /// A set of packages to build.
     pub spec: Packages<'a>,
     /// Filter to apply to the root package to select which targets will be
     /// built.
@@ -86,6 +86,23 @@ pub enum Packages<'a> {
     Packages(&'a [String]),
 }
 
+impl<'a> Packages<'a> {
+    pub fn into_package_id_specs(self, ws: &Workspace) -> CargoResult<Vec<PackageIdSpec>> {
+        let specs = match self {
+            Packages::All => {
+                ws.members()
+                    .map(Package::package_id)
+                    .map(PackageIdSpec::from_package_id)
+                    .collect()
+            }
+            Packages::Packages(packages) => {
+                packages.iter().map(|p| PackageIdSpec::parse(&p)).collect::<CargoResult<Vec<_>>>()?
+            }
+        };
+        Ok(specs)
+    }
+}
+
 pub enum CompileFilter<'a> {
     Everything,
     Only {
@@ -112,8 +129,8 @@ pub fn resolve_dependencies<'a>(ws: &Workspace<'a>,
                                 features: &[String],
                                 all_features: bool,
                                 no_default_features: bool,
-                                specs: &Packages<'a>)
-                                -> CargoResult<(Vec<PackageIdSpec>, PackageSet<'a>, Resolve)> {
+                                specs: &[PackageIdSpec])
+                                -> CargoResult<(PackageSet<'a>, Resolve)> {
     let features = features.iter().flat_map(|s| {
         s.split_whitespace()
     }).map(|s| s.to_string()).collect::<Vec<String>>();
@@ -147,18 +164,6 @@ pub fn resolve_dependencies<'a>(ws: &Workspace<'a>,
         }
     };
 
-    let specs = match *specs {
-        Packages::All => {
-            ws.members()
-                .map(Package::package_id)
-                .map(PackageIdSpec::from_package_id)
-                .collect()
-        }
-        Packages::Packages(packages) => {
-            packages.iter().map(|p| PackageIdSpec::parse(&p)).collect::<CargoResult<Vec<_>>>()?
-        }
-    };
-
     let resolved_with_overrides =
             ops::resolve_with_previous(&mut registry, ws,
                                             method, Some(&resolve), None,
@@ -175,7 +180,7 @@ pub fn resolve_dependencies<'a>(ws: &Workspace<'a>,
     let packages = ops::get_resolved_packages(&resolved_with_overrides,
                                               registry);
 
-    Ok((specs, packages, resolved_with_overrides))
+    Ok((packages, resolved_with_overrides))
 }
 
 pub fn compile_ws<'a>(ws: &Workspace<'a>,
@@ -197,17 +202,18 @@ pub fn compile_ws<'a>(ws: &Workspace<'a>,
 
     let profiles = ws.profiles();
 
+    let specs = spec.into_package_id_specs(ws)?;
     let resolve = resolve_dependencies(ws,
                                        source,
                                        features,
                                        all_features,
                                        no_default_features,
-                                       &spec)?;
-    let (spec, packages, resolve_with_overrides) = resolve;
+                                       &specs)?;
+    let (packages, resolve_with_overrides) = resolve;
 
     let mut pkgids = Vec::new();
-    if spec.len() > 0 {
-        for p in spec.iter() {
+    if specs.len() > 0 {
+        for p in specs.iter() {
             pkgids.push(p.query(resolve_with_overrides.iter())?);
         }
     } else {
diff --git a/src/cargo/ops/cargo_output_metadata.rs b/src/cargo/ops/cargo_output_metadata.rs
index 2856d1658..673e753bc 100644
--- a/src/cargo/ops/cargo_output_metadata.rs
+++ b/src/cargo/ops/cargo_output_metadata.rs
@@ -43,17 +43,18 @@ fn metadata_no_deps(ws: &Workspace,
 
 fn metadata_full(ws: &Workspace,
                  opt: &OutputMetadataOptions) -> CargoResult<ExportInfo> {
+    let specs = Packages::All.into_package_id_specs(ws)?;
     let deps = ops::resolve_dependencies(ws,
                                          None,
                                          &opt.features,
                                          opt.all_features,
                                          opt.no_default_features,
-                                         &Packages::All)?;
-    let (_, packages, resolve) = deps;
+                                         &specs)?;
+    let (packages, resolve) = deps;
 
-    let packages = try!(packages.package_ids()
-                                .map(|i| packages.get(i).map(|p| p.clone()))
-                                .collect());
+    let packages = packages.package_ids()
+                           .map(|i| packages.get(i).map(|p| p.clone()))
+                           .collect::<CargoResult<Vec<_>>>()?;
 
     Ok(ExportInfo {
         packages: packages,
-- 
2.30.2